/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package managedBean;

import entities.Chanson;
import entities.ListeLecture;
import entities.Utilisateur;
import java.io.File;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.inject.Named;
import javax.faces.bean.SessionScoped;
import org.blinkenlights.jid3.MP3File;
import org.blinkenlights.jid3.MediaFile;
import session.AlbumManager;
import session.ArtisteManager;
import session.ChansonManager;
import session.ListeLectureManager;
import session.UtilisateurManager;
import rumbleToolkit.Mp3AnalyzerTool;

/**
 *
 * @author Nordinator
 */
//@Named(value = "mp3LibraryMBean")
//@Dependent
@ManagedBean
@SessionScoped
public class Mp3LibraryMBean {

    @EJB
    private UtilisateurManager utilisateurManager;
    private List<Utilisateur> listUser;
    private Utilisateur utilisateur;
    @EJB
    private ListeLectureManager listeLectureManager;
    private List<ListeLecture> collectListeLecture;
    private ListeLecture listeLecture;
    @EJB
    private ChansonManager chansonManager;
    private List<Chanson> listChanson;
    @EJB
    private ArtisteManager artisteManager;
    @EJB
    private AlbumManager albumManager;
    private String index = "test";
    private String path = "D:\\";
    private String filtre = "(.*).mp3";

    
    /** Creates a new instance of Mp3LibraryMBean */
    public Mp3LibraryMBean() {
    }

    /**
     * Méthode récupère la liste des utilisateurs
     * @return
     * 
     */
    public List<Utilisateur> getUsers() {
        //Cette clause est fait pour éviter de recharger plusieurs fois la base pour rien
        if (listUser == null) {
            listUser = utilisateurManager.getAllUtilisateur();
        }
        return listUser;
    }

    /**
     * Cette méthode renvoi les details de l'utilisateur courant
     * @return
     */
    public Utilisateur getDetails() {
        return utilisateur;
    }
    
    //Partie qui concerne les utilisateurs
    /**
     * Methode d'ajout d'utilisateur en phase avec la page web
     * @return
     */
    public String addNewUSer(String nom, String password){
        utilisateurManager.createUtilisateur(nom, password);
        return index;
    }
    
    /**
     * Cette méthode sauvegarde l'utilisateur courant
     * @return
     */
    public String saveCurrentUser(Utilisateur user) {
        utilisateur = user;
        return index;
    }
    
    /**
     * Avant de quitter la session il faut ua préalable enregistrer les données
     * @return
     */
    public String logout() {
        utilisateurManager.update(utilisateur);
        return index;
    }
    
    //Methodes qui suivent, servent à exécuter lors de la creation d'une playlist
    /**
     * Ajoute la playlist cree a l'utilisateur
     * @return 
     */
    public String createPlayList(String name){
        listeLecture = new ListeLecture(name);
        return index;
    }
    
    /**
     * Cette méthode permet d'ajouter une chanson dans un playlist
     * 
     * @return
     */
    public String addSongIntoPlayList(Long idSong){
        if(listeLecture != null){
            listeLecture.addSong(idSong);
        }else{
            System.out.println("Mp3LibraryMBean.addSongIntoPlayList : Aucune liste de lecture n'a été chargé !");
        }
        return index;
    }
    
    /**
     * Permute la position de chanson dans la liste de lecture
     * N.B. La playlist devra petre chargé au préalable
     * @return
     */
    public String changePlayListOrder(int song1, int song2){
        if(listeLecture != null){
            //listeLecture.permutSong(song1, song2);
        }else{
            System.out.println("Mp3LibraryMBean.changePlayListOrder : Aucune PlayList n'a été chargé !");
        }
        return index;
    }
    
    /**
     * MHandler sauvegarde liste de lecture
     */
    public void saveListeLecture(){
        listeLectureManager.addListeLecture(listeLecture);
    }
    
    /**
     * Efface une playlist
     * @param
     */
    public String deletPlayList(Long id){
        
        return index;
    }
    
    /**
     * Methode
     * @return
     */
    public String loadAPL(Long idPlayList){
        listeLectureManager.getAListeDeLecture(idPlayList);
        return index;
    }
    
    /**
     * Handler de sauvegarde de la playlist
     * @return
     */
    public String savePlayList(){
        utilisateur.ajouterListeLecture(listeLecture.getId());
        return index;
    }
    
    /**
     * Charger toute les playList d'un utilisateur
     * @return 
     */
    public String getAllPlayListFromUser(){
        if(utilisateur != null){
            for(Long i : utilisateur.getListesLectures()){
                collectListeLecture = new ArrayList<ListeLecture>();
                collectListeLecture.add(listeLectureManager.getAListeDeLecture(i));
            }
        }else{
            System.out.println("Mp3LibreryMBean : aucun utilisateur n'a été récupéré !!");
            return index;
        }
        return index;
    }
    
    /**
     * 
     */
    public String refreshUser(){
        utilisateur = utilisateurManager.getAUser(path);
        return index;
    }
    

    /**
     * Methode de récupération des chansons
     * @return 
     */
    public String getDetailsSong(){
        listChanson = chansonManager.getAllSongs();
        //a modifier pour rediriger vers un site
        return index;
    }
    
    /**
     * 
     * @param url
     * @return 
     */
    public String setPath(String url){
        this.path = url;
        return index;
    }

    /**
     * Cette méthode scan le dossier courant et inscript les
     * @return
     */
    public String folderAnalyser() {
        //Analyser de l'url afin de déceler les fichiers mp3
        Pattern p = Pattern.compile(filtre);
        String[] s = new File(path).list();
        int errorMP3File = 0;
        for (int i = 0; i < s.length; i++) {
            //verification de l'extension .mp3
            Matcher m = p.matcher(s[i]);
            if (m.matches()) {
                //Creation et enregistrement dans la base de donnée
                File oSourceFile = new File(path + s[i]);
                MediaFile oMediaFile = new MP3File(oSourceFile);
                Hashtable<String, String> listTag = Mp3AnalyzerTool.mp3analyzer(oMediaFile);
                if(!listTag.isEmpty()){
                    //creation enregistement d'un chanson ds la base de donnée : on gère le cas ou le genre n'est pas dans le tag
                    chansonManager.ajouterChanson(listTag.get("title"), path + s[i], 
                            (listTag.containsKey("genre")) ? listTag.get("genre") : "");
                    //creation d'un artiste avec gestion des artistes inconnue
                    artisteManager.ajouterArtiste((listTag.containsKey("artiste") ? listTag.get("artiste") : "unknown"),
                                (listTag.containsKey("album")) ? listTag.get("album") : "unknown");
                    //creation d'un album avec gestion d'un album inconnue
                    albumManager.ajouterAlbum((listTag.containsKey("album")) ? listTag.get("album") : "unknown",
                            listTag.containsKey("artiste") ? listTag.get("artiste") : "unknown");
                }else{
                    errorMP3File++;
                }
            }
        }
        System.out.println("Il y a "+errorMP3File+" non prise en charge !");
        return index;
    }
    
    //Les méthodes suivants concernent la modification des playList

    
    /**
     * Methode de test de fonction
     */
    public String test(){
        artisteManager.Test();
        return index;
    }
}
